
using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Text;
using ProjectCommon2.Interfaces;


namespace PolePosition.v3.EntityLibrary
{
	// No comments for the class here, all are in Entity.cs.cst
    [DataContract(Namespace = "http://Chfa.DataContracts/2007/10", Name = "Project")]
	public sealed partial class ProjectEntity
		: Classes.Bases.Entity, ProjectCommon2.Interfaces.ICustomEntity	   
	{
		/// <summary>
		/// Determines if a default value (equivalent to the database's default value) is returned when the value of a <c>null</c> property is requested. 
		/// This makes sure that the stored checksum of a <c>ProjectEntity</c> with <c>null</c> properties matches the checksum calculated
		/// the next time it is loaded from the database.
		/// </summary>
		/// <remarks>
		/// <para>
		/// This variable exists to solve the checksum discrepancy that arises because the database replaces <c>null</c> values with its own default values
		/// (note that this is only relevant for those Entities for which verifying the checksum is important). An explanation follows.</para>
		///
		/// <para>A <c>ProjectEntity</c> can contain properties whose values are <c>null</c> (either because they have not been set, or because they were
		/// explicitly set that way). If a <c>ProjectEntity</c> is persisted to the database in that state, some of the <c>null</c> values will be replaced
		/// with default values by the database. However, before the Entity is persisted to the database, a checksum is calculated for its non-null values, and this
		/// checksum is stored in the database along with the rest of its values in order to validate it next time the Entity is loaded (see how the 
		/// <see cref="CheckSum" /> property works).
		/// </para>
		/// <para>Obviously, the original checksum calculated for an Entity with <c>null</c> properties will differ from the one calculated from its values
		/// the next time it is loaded from the database, since some of the null values were replaced by default values. Performing a checksum test on this Entity
		/// would raise a false <see cref="ProjectCommon2.Exceptions.EntityCheckSumSecurityException" />.
		/// </para>
		/// <para>To avoid this, <c>EnableDefaults</c> should be set to <c>true</c> for those Entities before persisting them to the database. If this is done,
		/// the Entity's column properties do not simply return <c>null</c> if its values are <c>null</c>. Instead, they return a value equivalent to the one the
		/// database would create for the <c>null</c> values (see the documentation for any of the column properties to see how they work). In this way, the
		/// Entity's original checksum, the one stored in the database, is created from the same values that will be used to calculate a checksum the next time 
		/// the Entity is loaded, thus eliminating the checksum discrepancy.
		/// </para>
		/// </remarks>
		public bool EnableDefaults;

		#region " Column Properties "
		
			
			
				
					// ActualCost
					/// <summary>
					/// Stores the value of the ActualCost column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ActualCost</c>),
					/// but through the <see cref="ActualCostObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ActualCostObject" /> or the <see cref="ActualCost" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<decimal?> prop_ActualCost;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ActualCost column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ActualCost column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ActualCost" /> member or the <see cref="ActualCost" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ActualCost" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<decimal?> ActualCostObject
					{
						get
						{
							if (prop_ActualCost == null)
							{
								prop_ActualCost = new ProjectCommon2.Helpers.PropertyHelper<decimal?>();
							}
							return prop_ActualCost;
						}
						private set
						{
							prop_ActualCost = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ActualCost
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ActualCost" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ActualCostObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ActualCost</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ActualCost corresponds to the database column "tb_Vendor_Projects.ActualCost". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 9.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 19.</item>
					/// <item>Scale: 2.</item>
					/// <item>System type: System.Decimal.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ActualCost' />.</value>
					[DataMember()]
					public decimal? ActualCost
					{
						get
						{
							if (EnableDefaults & ActualCostObject.IsNull)
							{
								return null;
							}
							return ActualCostObject.Value;
						}
						set
						{
							ActualCostObject.Value = value;
						}
					}
				
					// ActualEndDate
					/// <summary>
					/// Stores the value of the ActualEndDate column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ActualEndDate</c>),
					/// but through the <see cref="ActualEndDateObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ActualEndDateObject" /> or the <see cref="ActualEndDate" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<DateTime?> prop_ActualEndDate;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ActualEndDate column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ActualEndDate column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ActualEndDate" /> member or the <see cref="ActualEndDate" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ActualEndDate" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<DateTime?> ActualEndDateObject
					{
						get
						{
							if (prop_ActualEndDate == null)
							{
								prop_ActualEndDate = new ProjectCommon2.Helpers.PropertyHelper<DateTime?>();
							}
							return prop_ActualEndDate;
						}
						private set
						{
							prop_ActualEndDate = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ActualEndDate
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ActualEndDate" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ActualEndDateObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ActualEndDate</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ActualEndDate corresponds to the database column "tb_Vendor_Projects.ActualEndDate". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 23.</item>
					/// <item>Scale: 3.</item>
					/// <item>System type: System.DateTime.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ActualEndDate' />.</value>
					[DataMember()]
					public DateTime? ActualEndDate
					{
						get
						{
							if (EnableDefaults & ActualEndDateObject.IsNull)
							{
								return null;
							}
							return ActualEndDateObject.Value;
						}
						set
						{
							ActualEndDateObject.Value = value;
						}
					}
				
					// ActualStartDate
					/// <summary>
					/// Stores the value of the ActualStartDate column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ActualStartDate</c>),
					/// but through the <see cref="ActualStartDateObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ActualStartDateObject" /> or the <see cref="ActualStartDate" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<DateTime?> prop_ActualStartDate;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ActualStartDate column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ActualStartDate column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ActualStartDate" /> member or the <see cref="ActualStartDate" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ActualStartDate" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<DateTime?> ActualStartDateObject
					{
						get
						{
							if (prop_ActualStartDate == null)
							{
								prop_ActualStartDate = new ProjectCommon2.Helpers.PropertyHelper<DateTime?>();
							}
							return prop_ActualStartDate;
						}
						private set
						{
							prop_ActualStartDate = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ActualStartDate
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ActualStartDate" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ActualStartDateObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ActualStartDate</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ActualStartDate corresponds to the database column "tb_Vendor_Projects.ActualStartDate". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 23.</item>
					/// <item>Scale: 3.</item>
					/// <item>System type: System.DateTime.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ActualStartDate' />.</value>
					[DataMember()]
					public DateTime? ActualStartDate
					{
						get
						{
							if (EnableDefaults & ActualStartDateObject.IsNull)
							{
								return null;
							}
							return ActualStartDateObject.Value;
						}
						set
						{
							ActualStartDateObject.Value = value;
						}
					}
				
					// Name
					/// <summary>
					/// Stores the value of the Name column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Name</c>),
					/// but through the <see cref="NameObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="NameObject" /> or the <see cref="Name" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_Name;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Name column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Name column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Name" /> member or the <see cref="Name" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Name" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> NameObject
					{
						get
						{
							if (prop_Name == null)
							{
								prop_Name = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_Name;
						}
						private set
						{
							prop_Name = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Name
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Name" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="NameObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Name</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Name corresponds to the database column "tb_Vendor_Projects.Name". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 50.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Name' />.</value>
					[DataMember()]
					public string Name
					{
						get
						{
							if (EnableDefaults & NameObject.IsNull)
							{
								return null;
							}
							return NameObject.Value;
						}
						set
						{
							NameObject.Value = value;
						}
					}
				
					// ProjectTypeFk
					/// <summary>
					/// Stores the value of the ProjectTypeFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ProjectTypeFk</c>),
					/// but through the <see cref="ProjectTypeFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ProjectTypeFkObject" /> or the <see cref="ProjectTypeFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_ProjectTypeFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ProjectTypeFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ProjectTypeFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ProjectTypeFk" /> member or the <see cref="ProjectTypeFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ProjectTypeFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> ProjectTypeFkObject
					{
						get
						{
							if (prop_ProjectTypeFk == null)
							{
								prop_ProjectTypeFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_ProjectTypeFk;
						}
						private set
						{
							prop_ProjectTypeFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ProjectTypeFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ProjectTypeFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ProjectTypeFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ProjectTypeFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ProjectTypeFk corresponds to the database column "tb_Vendor_Projects.ProjectTypeFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ProjectTypeFk' />.</value>
					[DataMember()]
					public int? ProjectTypeFk
					{
						get
						{
							if (EnableDefaults & ProjectTypeFkObject.IsNull)
							{
								return null;
							}
							return ProjectTypeFkObject.Value;
						}
						set
						{
							ProjectTypeFkObject.Value = value;
						}
					}
				
					// ScheduledCost
					/// <summary>
					/// Stores the value of the ScheduledCost column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ScheduledCost</c>),
					/// but through the <see cref="ScheduledCostObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ScheduledCostObject" /> or the <see cref="ScheduledCost" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<decimal?> prop_ScheduledCost;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ScheduledCost column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ScheduledCost column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ScheduledCost" /> member or the <see cref="ScheduledCost" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ScheduledCost" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<decimal?> ScheduledCostObject
					{
						get
						{
							if (prop_ScheduledCost == null)
							{
								prop_ScheduledCost = new ProjectCommon2.Helpers.PropertyHelper<decimal?>();
							}
							return prop_ScheduledCost;
						}
						private set
						{
							prop_ScheduledCost = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ScheduledCost
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ScheduledCost" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ScheduledCostObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ScheduledCost</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ScheduledCost corresponds to the database column "tb_Vendor_Projects.ScheduledCost". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 9.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 19.</item>
					/// <item>Scale: 2.</item>
					/// <item>System type: System.Decimal.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ScheduledCost' />.</value>
					[DataMember()]
					public decimal? ScheduledCost
					{
						get
						{
							if (EnableDefaults & ScheduledCostObject.IsNull)
							{
								return null;
							}
							return ScheduledCostObject.Value;
						}
						set
						{
							ScheduledCostObject.Value = value;
						}
					}
				
					// ScheduledEndDate
					/// <summary>
					/// Stores the value of the ScheduledEndDate column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ScheduledEndDate</c>),
					/// but through the <see cref="ScheduledEndDateObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ScheduledEndDateObject" /> or the <see cref="ScheduledEndDate" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<DateTime?> prop_ScheduledEndDate;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ScheduledEndDate column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ScheduledEndDate column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ScheduledEndDate" /> member or the <see cref="ScheduledEndDate" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ScheduledEndDate" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<DateTime?> ScheduledEndDateObject
					{
						get
						{
							if (prop_ScheduledEndDate == null)
							{
								prop_ScheduledEndDate = new ProjectCommon2.Helpers.PropertyHelper<DateTime?>();
							}
							return prop_ScheduledEndDate;
						}
						private set
						{
							prop_ScheduledEndDate = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ScheduledEndDate
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ScheduledEndDate" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ScheduledEndDateObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ScheduledEndDate</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ScheduledEndDate corresponds to the database column "tb_Vendor_Projects.ScheduledEndDate". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 23.</item>
					/// <item>Scale: 3.</item>
					/// <item>System type: System.DateTime.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ScheduledEndDate' />.</value>
					[DataMember()]
					public DateTime? ScheduledEndDate
					{
						get
						{
							if (EnableDefaults & ScheduledEndDateObject.IsNull)
							{
								return null;
							}
							return ScheduledEndDateObject.Value;
						}
						set
						{
							ScheduledEndDateObject.Value = value;
						}
					}
				
					// ScheduledStartDate
					/// <summary>
					/// Stores the value of the ScheduledStartDate column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ScheduledStartDate</c>),
					/// but through the <see cref="ScheduledStartDateObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ScheduledStartDateObject" /> or the <see cref="ScheduledStartDate" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<DateTime?> prop_ScheduledStartDate;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ScheduledStartDate column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ScheduledStartDate column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ScheduledStartDate" /> member or the <see cref="ScheduledStartDate" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ScheduledStartDate" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<DateTime?> ScheduledStartDateObject
					{
						get
						{
							if (prop_ScheduledStartDate == null)
							{
								prop_ScheduledStartDate = new ProjectCommon2.Helpers.PropertyHelper<DateTime?>();
							}
							return prop_ScheduledStartDate;
						}
						private set
						{
							prop_ScheduledStartDate = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ScheduledStartDate
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ScheduledStartDate" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ScheduledStartDateObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ScheduledStartDate</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ScheduledStartDate corresponds to the database column "tb_Vendor_Projects.ScheduledStartDate". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 23.</item>
					/// <item>Scale: 3.</item>
					/// <item>System type: System.DateTime.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ScheduledStartDate' />.</value>
					[DataMember()]
					public DateTime? ScheduledStartDate
					{
						get
						{
							if (EnableDefaults & ScheduledStartDateObject.IsNull)
							{
								return null;
							}
							return ScheduledStartDateObject.Value;
						}
						set
						{
							ScheduledStartDateObject.Value = value;
						}
					}
				
					// StatusFk
					/// <summary>
					/// Stores the value of the StatusFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>StatusFk</c>),
					/// but through the <see cref="StatusFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="StatusFkObject" /> or the <see cref="StatusFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_StatusFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the StatusFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the StatusFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_StatusFk" /> member or the <see cref="StatusFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_StatusFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> StatusFkObject
					{
						get
						{
							if (prop_StatusFk == null)
							{
								prop_StatusFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_StatusFk;
						}
						private set
						{
							prop_StatusFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the StatusFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_StatusFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="StatusFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_StatusFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// StatusFk corresponds to the database column "tb_Vendor_Projects.StatusFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_StatusFk' />.</value>
					[DataMember()]
					public int? StatusFk
					{
						get
						{
							if (EnableDefaults & StatusFkObject.IsNull)
							{
								return null;
							}
							return StatusFkObject.Value;
						}
						set
						{
							StatusFkObject.Value = value;
						}
					}
				
					// TypeFk
					/// <summary>
					/// Stores the value of the TypeFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>TypeFk</c>),
					/// but through the <see cref="TypeFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="TypeFkObject" /> or the <see cref="TypeFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_TypeFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the TypeFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the TypeFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_TypeFk" /> member or the <see cref="TypeFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_TypeFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> TypeFkObject
					{
						get
						{
							if (prop_TypeFk == null)
							{
								prop_TypeFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_TypeFk;
						}
						private set
						{
							prop_TypeFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the TypeFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_TypeFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="TypeFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_TypeFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// TypeFk corresponds to the database column "tb_Vendor_Projects.TypeFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_TypeFk' />.</value>
					[DataMember()]
					public int? TypeFk
					{
						get
						{
							if (EnableDefaults & TypeFkObject.IsNull)
							{
								return null;
							}
							return TypeFkObject.Value;
						}
						set
						{
							TypeFkObject.Value = value;
						}
					}
				
					// UtilityFk
					/// <summary>
					/// Stores the value of the UtilityFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>UtilityFk</c>),
					/// but through the <see cref="UtilityFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="UtilityFkObject" /> or the <see cref="UtilityFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_UtilityFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the UtilityFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the UtilityFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_UtilityFk" /> member or the <see cref="UtilityFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_UtilityFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> UtilityFkObject
					{
						get
						{
							if (prop_UtilityFk == null)
							{
								prop_UtilityFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_UtilityFk;
						}
						private set
						{
							prop_UtilityFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the UtilityFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_UtilityFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="UtilityFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_UtilityFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// UtilityFk corresponds to the database column "tb_Vendor_Projects.UtilityFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_UtilityFk' />.</value>
					[DataMember()]
					public int? UtilityFk
					{
						get
						{
							if (EnableDefaults & UtilityFkObject.IsNull)
							{
								return null;
							}
							return UtilityFkObject.Value;
						}
						set
						{
							UtilityFkObject.Value = value;
						}
					}
				
					// Vendor_ProjectId
					/// <summary>
					/// Stores the value of the Vendor_ProjectId column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Vendor_ProjectId</c>),
					/// but through the <see cref="Vendor_ProjectIdObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="Vendor_ProjectIdObject" /> or the <see cref="Vendor_ProjectId" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_Vendor_ProjectId;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Vendor_ProjectId column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Vendor_ProjectId column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Vendor_ProjectId" /> member or the <see cref="Vendor_ProjectId" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Vendor_ProjectId" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> Vendor_ProjectIdObject
					{
						get
						{
							if (prop_Vendor_ProjectId == null)
							{
								prop_Vendor_ProjectId = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_Vendor_ProjectId;
						}
						private set
						{
							prop_Vendor_ProjectId = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Vendor_ProjectId
					/// column, which is (part of) the Primary Key of the Project table.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Vendor_ProjectId" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="Vendor_ProjectIdObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Vendor_ProjectId</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Vendor_ProjectId corresponds to the database column "tb_Vendor_Projects.Vendor_ProjectId". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  Yes. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  Yes  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  Yes. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Vendor_ProjectId' />.</value>
					[DataMember()]
					public int? Vendor_ProjectId
					{
						get
						{
							if (EnableDefaults & Vendor_ProjectIdObject.IsNull)
							{
								return null;
							}
							return Vendor_ProjectIdObject.Value;
						}
						set
						{
							Vendor_ProjectIdObject.Value = value;
						}
					}
				
					// VendorFK
					/// <summary>
					/// Stores the value of the VendorFK column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>VendorFK</c>),
					/// but through the <see cref="VendorFKObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="VendorFKObject" /> or the <see cref="VendorFK" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_VendorFK;
					
					/// <summary>
					/// Gets the helper object that stores the value of the VendorFK column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the VendorFK column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_VendorFK" /> member or the <see cref="VendorFK" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_VendorFK" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> VendorFKObject
					{
						get
						{
							if (prop_VendorFK == null)
							{
								prop_VendorFK = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_VendorFK;
						}
						private set
						{
							prop_VendorFK = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the VendorFK
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_VendorFK" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="VendorFKObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_VendorFK</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// VendorFK corresponds to the database column "tb_Vendor_Projects.VendorFK". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_VendorFK' />.</value>
					[DataMember()]
					public int? VendorFK
					{
						get
						{
							if (EnableDefaults & VendorFKObject.IsNull)
							{
								return null;
							}
							return VendorFKObject.Value;
						}
						set
						{
							VendorFKObject.Value = value;
						}
					}

			// Special: FriendlyName
			/// <summary>
			///	Stores the value of the FriendlyName column.
			/// </summary>
			/// <value>Human-readable form of <c>ProjectEntity</c>'s name.</value>
			private string prop_FriendlyName;

			/// <summary>
			/// Gets or Sets a value that contains a more descriptive, human-readable form of <c>ProjectEntity</c>'s name.
			/// </summary>
			/// <value>Human-readable form of <c>ProjectEntity</c>'s name.</value>
			/// <remarks>Although <c>Set</c> is available, this value is never written back to the database. It is 
			/// made up from other columns in the database by the stored procedure that retrieves <c>ProjectEntity</c>'s
			/// record from the database.</remarks>
			[DataMember()]
			public string FriendlyName
			{
				get
				{
					return prop_FriendlyName;
				}
				set
				{
					prop_FriendlyName = value;
				}
			}
			
		#endregion

		#region " Other Properties "
		
		/// <summary>
		/// Stores a manually set value that indicates if <c>ProjectEntity</c>'s data is new.
		/// </summary>
		/// <remarks>
		/// Normally, this field should stay <c>null</c> to let <see cref="IsNew" />'s logic
		/// decide whether to return <c>true</c> or <c>false</c>.
		/// </remarks>
		private bool? prop_IsNew;
		
		/// <summary>
		/// Gets or Sets a value that specifies whether <c>ProjectEntity</c> contains new Project data
		/// or data loaded from an existing Project record.
		/// <para> </para>
		/// <c>True</c> if the data is new; <c>false</c> if it is from an existing record.
		/// </summary>
		/// <remarks>
		/// <para>Provided that its associated field (<see cref="prop_IsNew" />) stays <c>null</c>, this property returns
		/// <c>true</c> if no Primary Key value exists for <c>ProjectEntity</c>; false if there is one. This determines
		/// if a persist command (calling ProjectFactory's <c>Save()</c> method) will cause an <c>INSERT</c> or an
		/// <c>UPDATE</c> in the database. For more information, see how
		/// <see cref="Classes.Factories.ProjectFactory.Save(Classes.Entities.ProjectEntity, bool)" /> works.
		/// </para>
		/// <para>Note that manually setting this property's value to something other than <c>null</c> will bypass its logic,
		/// and it will return whatever value it is set to, even if it is incorrect.</para>
		/// </remarks>
		/// <value>Indicates if <c>ProjectEntity</c>'s data is new. Can be set to <c>true</c> (to indicate new data), <c>false</c>, 
		/// or <c>null</c>.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public bool? IsNew
		{
			get
			{
				// support manually overriding the IsNew value
				if (prop_IsNew != null)
				{
                    return prop_IsNew;
				}
                // Check IsDirty of key only
                return (this.Vendor_ProjectIdObject.IsNull);
			}
			set
			{
				// manually override IsNew
				prop_IsNew = value;
			}
		}
		
		/// <summary>
		/// Stores a value that indicates whether <c>ProjectEntity</c> has been modified.
		/// </summary>
		/// <remarks>
		/// Normally, this field should stay <c>null</c> to let <see cref="IsDirty" />'s logic
		/// decide whether to return <c>true</c> or <c>false</c>.
		/// </remarks>
		private bool? prop_IsDirty;
		
		/// <summary>
		/// Gets a value that specifies whether <c>ProjectEntity</c>'s data has been modified since it was first loaded, or
		/// since the last time its <c>AcceptChanges()</c> method was called.
		/// <para> </para>
		/// <c>True</c> if the Entity has changed; <c>false</c> if it has not.
		/// </summary>
		/// <remarks>
		/// <para>Provided that its associated field (<see cref="prop_IsDirty" />) stays <c>null</c>, it returns <c>true</c> if
		/// the Entity's <see cref="IsNew" /> or <see cref="IsMarkedToDelete" /> properties are <c>true</c>. If none of them is, 
		/// it will check whether its <see cref="CheckSum" /> has changed and return an appropiate value based on the result of 
		/// that check.</para>
		/// <para>The value returned by <c>IsDirty</c> determines if a persist command (calling ProjectFactory's <c>Save()</c>)
		/// will <c>UPDATE</c> the corresponding record in the database. For more information, see how
		/// <see cref="Classes.Factories.ProjectFactory.Save(Classes.Entities.ProjectEntity, bool)" /> works.
		/// </para>
		/// <para>Note that manually setting this property's value to something other than <c>null</c> will bypass its logic,
		/// and it will return whatever value it is set to, even if it is incorrect.</para>
		/// </remarks>
		/// <value><c>Indicates if ProjectEntity</c> has been modified. <c>True</c> if it has; <c>false</c> otherwise.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public bool? IsDirty
		{
			get
			{
				
				// support manually overriding the IsDirty value
				if (prop_IsDirty != null)
				{
                    return prop_IsDirty;
				}

				if (IsNew == true)
					return true;
					
				if (IsMarkedToDelete == true)
					return true;
				
				if (CheckSumOriginal != CheckSum)
					return true;
					
				return RecurseBooleanProperty(this, "IsDirty");
			}
			private set
			{
				//only set the variable if manually set. Set is only available for serialization and should
				//only be used for reconstruction by deserialization.
				if (m_IsDirtyManuallySet)
					prop_IsDirty = value;
			}
		}
		
		//private variable supplied for deserialization, so that if the IsDirty was set manually the
		//prop_IsDirty can be set on reconstruction
		private bool m_IsDirtyManuallySet;
		
		/// <summary>
		/// Sets a value that indicates whether <c>ProjectEntity</c> has changed.
		/// <para> </para>
		/// Use <c>true</c> if the Entity has changed, <c>false</c> if not, or <c>null</c> to let
		/// the <see cref="IsDirty" /> property determine an appropiate value.
		/// </summary>
		/// <remarks>If set to something other than <c>null</c>, this overrides the <see cref="IsDirty" /> property's logic so that it will return the assigned
		/// value even if it is incorrect.</remarks>
		/// <value><c>Indicates if ProjectEntity</c> has been modified. <c>True</c> if it has; <c>false</c> otherwise.</value>
		public void SetManualIsDirty(bool? value)
		{
			// manually override IsDirty
			prop_IsDirty = value;
			
			if (value == null)
				m_IsDirtyManuallySet = false;
			else
				m_IsDirtyManuallySet = true;
			
		}

		/// <summary>
		/// Stores a value that indicates whether the <c>ProjectEntity</c> is to be deleted.
		/// </summary>
		private bool prop_IsMarkedToDelete;
		
		/// <summary>
		/// Gets or Sets a value that specifies whether <c>ProjectEntity</c>'s data is to be removed from the database.
		/// <para> </para>
		/// <c>True</c> deletes the Project data.
		/// </summary>
		/// <remarks>Determines if a persist command (calling ProjectFactory's <c>Save()</c>) will DELETE the Entity's
		/// corresponding record in the database. For more information, see how
		/// <see cref="Classes.Factories.ProjectFactory.Save(Classes.Entities.ProjectEntity, bool)" /> works.
		/// </remarks>
		/// <value><c>ProjectEntity</c>'s deletion mark. <c>True</c> to delete; <c>false</c> otherwise.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public bool IsMarkedToDelete
		{
			get
			{
				return prop_IsMarkedToDelete;
			}
			set
			{
				prop_IsMarkedToDelete = value;
			}
		}

		/// <summary>
		/// Gets a unique checksum for <c>ProjectEntity</c>, calculated from its current property values.
		/// </summary>
		/// <remarks>
		/// <para>This property creates a checksum for <c>ProjectEntity</c>'s values by calling
		/// <see cref="PolePosition.v3.EntityLibrary.Entity.MakeHash" />, and sending it every column property's values, except for Checksum,
		/// the Primary Key, and any <c>null</c> properties.
		///</para>
		/// <para>The checksum is stored in the database along with the rest of <c>ProjectEntity</c>'s values when it is
		/// created or modified. Then, whenever <c>ProjectEntity</c> is loaded from the database, a new checksum is calculated
		/// on the loaded values and compared to the stored checksum (see <see cref="LoadFromDataRow(System.Data.DataRow, bool)" />).
		/// Because the checksum is unique for a specified set of values, if the database values were modified by someone without proper
		/// authorization, the checksums will not match, and an <see cref="ProjectCommon2.Exceptions.EntityCheckSumSecurityException" />
		/// will be thrown.
		/// </para>
		/// </remarks>
		/// <value>String that uniquely identifies the contents of the Entity it belongs to.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public string CheckSum
		{
			get
			{
				System.Text.StringBuilder sb = new System.Text.StringBuilder();
				if (this.VendorFK != null) { sb.Append(this.VendorFK.ToString()); }
				if (this.Name != null) { sb.Append(this.Name.ToString()); }
				if (this.ScheduledStartDate != null) { sb.Append(this.ScheduledStartDate.ToString()); }
				if (this.ActualStartDate != null) { sb.Append(this.ActualStartDate.ToString()); }
				if (this.ScheduledEndDate != null) { sb.Append(this.ScheduledEndDate.ToString()); }
				if (this.ActualEndDate != null) { sb.Append(this.ActualEndDate.ToString()); }
				if (this.ScheduledCost != null) { sb.Append(this.ScheduledCost.ToString()); }
				if (this.ActualCost != null) { sb.Append(this.ActualCost.ToString()); }
				if (this.TypeFk != null) { sb.Append(this.TypeFk.ToString()); }
				if (this.StatusFk != null) { sb.Append(this.StatusFk.ToString()); }
				if (this.UtilityFk != null) { sb.Append(this.UtilityFk.ToString()); }
				if (this.ProjectTypeFk != null) { sb.Append(this.ProjectTypeFk.ToString()); }
				
				return MakeHash(sb.ToString());
			}
			private set
			{
					//Intentionally not implimented. Set is only available for serialization.
					//Due to reconstruction of the object upon deserialization in WCF this set
					//is called regardless of whether it is private. For this reason the method
					//contains no code nor a NotImplemented exception.
			}
		}
		
		/// <summary>
		/// Stores the string that represents the original checksum for <c>ProjectEntity</c>.
		/// </summary>
		private string prop_CheckSumOriginal = string.Empty;
		/// <summary>
		/// Gets or Sets the original checksum loaded from the database when <c>ProjectEntity</c> was first constructed.
		/// </summary>
		/// <remarks>Stored so that its value can be compared to the checksum in the database record when writing <c>ProjectEntity</c> 
		/// back to the database. When checksum verification is used, this comparison makes sure that <c>ProjectFactory</c> is writing to the correct, 
		/// and unmodified, record from which <c>ProjectEntity</c> was created.
		/// </remarks>
		/// <value>Original checksum value loaded from the database for <c>ProjectEntity</c>.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public string CheckSumOriginal
		{
			get
			{
				return prop_CheckSumOriginal;
			}
			set
			{
				prop_CheckSumOriginal = value;
			}
		}
		#endregion
		
	}
}

